package com.li.taskcenter.utils;

import com.li.taskcenter.domain.quartz.QuartzBean;
import com.li.taskcenter.domain.taskcenter.TaskInfo;
import org.quartz.*;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.util.List;

/**
 * @Description：
 * @Author：LiDong
 * @Create：2020/12/15
 * @Version：1.0.0
 */
public class QuartzUtils {

    private QuartzUtils() {
    }

    private final static Logger logger = LoggerFactory.getLogger(QuartzUtils.class);

    /**
     * 创建定时任务 定时任务创建之后默认启动状态
     *
     * @param scheduler  调度器
     * @param quartzBean 定时任务信息类
     * @throws Exception
     */
    public static void createScheduleJob(Scheduler scheduler, QuartzBean quartzBean) {
        try {
            //获取到定时任务的执行类  必须是类的绝对路径名称
            //定时任务类需要是job类的具体实现 QuartzJobBean是job的抽象类。
            Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(quartzBean.getJobClass());
            // 构建定时任务信息
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(quartzBean.getJobName()).build();
            // 设置定时任务执行方式
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
            // 构建触发器trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(quartzBean.getJobName()).withSchedule(scheduleBuilder).build();
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (ClassNotFoundException e) {
            logger.error("定时任务类路径出错：请输入类的绝对路径");
        } catch (SchedulerException e) {
            logger.error("创建定时任务出错：{}", e.getMessage());
        }
    }

    /**
     * 根据任务名称暂停定时任务
     *
     * @param scheduler 调度器
     * @param jobName   定时任务名称
     * @throws SchedulerException
     */
    public static void pauseScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
            logger.error("暂停定时任务出错：" + e.getMessage());
        }
    }

    /**
     * 根据任务名称恢复定时任务
     *
     * @param scheduler 调度器
     * @param jobName   定时任务名称
     * @throws SchedulerException
     */
    public static void resumeScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            logger.error("启动定时任务出错：{}", e.getMessage());
        }
    }

    /**
     * 根据任务名称立即运行一次定时任务
     *
     * @param scheduler 调度器
     * @param jobName   定时任务名称
     * @param taskInfo
     * @throws SchedulerException
     */
    public static boolean runOnce(Scheduler scheduler, String jobName, TaskInfo taskInfo) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            List<? extends Trigger> triggersOfJob = scheduler.getTriggersOfJob(jobKey);
            if (CollectionUtils.isEmpty(triggersOfJob)) {
                boolean flag = false;
                for (Trigger trigger : triggersOfJob) {
                    if (jobKey.equals(trigger.getJobKey())) {
                        flag = true;
                    }
                }
                // 当前任务没有Trigger则新建
                if (!flag) {
                    // 定义QuartzBean
                    QuartzBean quartzBean = new QuartzBean();
                    // 定义任务执行的类
                    quartzBean.setJobClass("com.li.taskcenter.controller.quartz.MyTask");
                    // 定义任务的名称唯一
                    quartzBean.setJobName(taskInfo.getTaskcode());
                    // corn表达式
                    quartzBean.setCronExpression(taskInfo.getCorn());
                    // 创建任务执行执行
                    QuartzUtils.createScheduleJob(scheduler, quartzBean);
                    // 停止执行
                    QuartzUtils.pauseScheduleJob(scheduler, quartzBean.getJobName());
                }
            }
            // 执行一次
            logger.info("=====> 任务执行一次开始...");
            scheduler.triggerJob(jobKey);
            logger.info("=====> 任务执行一次结束...");
            return true;
        } catch (SchedulerException e) {
            logger.error("运行定时任务出错：{}", e.getMessage());
            return false;
        }
    }

    /**
     * 更新定时任务
     *
     * @param scheduler  调度器
     * @param quartzBean 定时任务信息类
     * @throws SchedulerException
     */
    public static void updateScheduleJob(Scheduler scheduler, QuartzBean quartzBean) {
        try {
            //获取到对应任务的触发器
            TriggerKey triggerKey = TriggerKey.triggerKey(quartzBean.getJobName());
            //设置定时任务执行方式
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
            //重新构建任务的触发器trigger
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            //重置对应的job
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            logger.error("更新定时任务出错：{}", e.getMessage());
        }
    }

    /**
     * 根据定时任务名称从调度器当中删除定时任务
     *
     * @param scheduler 调度器
     * @param jobName   定时任务名称
     * @throws SchedulerException
     */
    public static void deleteScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.deleteJob(jobKey);
        } catch (SchedulerException e) {
            logger.error("删除定时任务出错：" + e.getMessage());
        }
    }
}
